package com.neusoft.exercise;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class HomeworkArray {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// 数组初始化
		// testArray01();
		// 复制数组
//		 copyArr();
//		// 给定一个数组，调用方法
//		 int[] array01 = { 1, 6, 2, 3, 9, 4, 5, 7, 8 };
//		 Arrays.sort(array01);
//		 // 遍历输出数组
//		 for (int k = 0; k < array01.length; k++) {
//		 System.out.print(array01[k] + ",");
//		 }
//		 System.out.println();
		// // 调用冒泡排序
		// bubbleSort(array01);
		// 矩阵乘法
		matrixMulti();
		//double型二维数组
		//doubleArr();
		//定义一个数组2
//		 int[] array02= {18,25,7,36,13,2,89,63};
		 //找最大值和下标
//		 Max(array02);
		//把数组逆序排放
//		 System.out.println("原始数组排放");
//		 for (int k = 0; k < array02.length; k++) {
//			 System.out.print(array02[k] + ",");
//			 }
//			 System.out.println();
//		reverse(array02);
//		 int[] array03= {18,25,18,36,13,2,2,63};
//		 System.out.println("原始数组为：");
//		 for (int k = 0; k < array02.length; k++) {
//			 System.out.print(array02[k] + ",");
//			 }
//			 System.out.println();
//		 onlyOne(array03);
		 //输出数组中的最大值最小值平均值
//		 minMax();
//		 minMaxCollections();
//		 
		 
		 
	}
	
	
	
	
	/**
	 * 集合类 Collections
	 * 9-2.给定一维数组{ -10，2，3，246，-100，0，5} ，
	 * 计算出数组中的平均值、最大值、最小值。
	 * （知识点：数组遍历、数组元素访问） [选作题]
	 */
	private static void minMaxCollections() {
		// 定义数组
		Integer[] arr = new Integer[] { -10, 2, 3, 246, -100, 0, 5 };
		// 定义数组中的最大值，初始化为arr[0]
		int max ;
		// 定义数组中的最小值，初始化为arr[0]
		int min;
		// 定义求和参数
		int iSum = 0;
		//集合类 数组定义int max方法报错，定义为Integer才可以使用
		max = Collections.max(Arrays.asList(arr));
		min = Collections.min(Arrays.asList(arr));
		//计算数组求和
		for(int i=0;i<arr.length;i++) {
			iSum+=arr[i];
		}
		//输出最大值最小值
		System.out.println("max = "+max);
		System.out.println("min = "+min);
		System.out.println("avg = "+(double)iSum/arr.length);
		
		System.out.println("===============反转整型数组==================");
		//用集合反转类
		Collections.reverse(Arrays.asList(arr));
		//遍历数组输出
		for(int i=0;i<arr.length;i++) {
			System.out.print(arr[i] +" ");
		}
		System.out.println();
		
		
		System.out.println("================反转字符串数组===============");
		//定义数组链表,并分配内存
		ArrayList<String> arrayList1 = new ArrayList<>();
		//给链表内赋值
		arrayList1.add("while");
		arrayList1.add("do");
		arrayList1.add("for");
		arrayList1.add("new");
		arrayList1.add("if");
		System.out.println("反转前排序"+arrayList1);
		Collections.reverse(arrayList1);
		System.out.println("反转后排序"+arrayList1);
		
		//整型数组链表
		
		ArrayList<Integer> arrayList2=new ArrayList<>();
		arrayList2.add(1230);
		arrayList2.add(3);
		arrayList2.add(2123);
		arrayList2.add(23);
		arrayList2.add(1233);
		
		
		System.out.println("===============数组复制===============");
		// ERROR这是打arrayLis。add时默认出来的，但是有问题
		//数组复制
		Integer[] arr2 = new Integer[arr.length + 1];
		System.arraycopy(arr, 0, arr2, 0, arr.length);
		for(int i = 0;i<arr2.length;i++) {
			System.out.print(arr2[i]+" ");
		}
		//存在问题
		//arr2[arr.length] = arrayList2;
		
		

	}
	
	/**
	 * 9-1.给定一维数组{ -10，2，3，246，-100，0，5} ，
	 * 计算出数组中的平均值、最大值、最小值。
	 * （知识点：数组遍历、数组元素访问） [选作题]
	 */
	private static void minMax() {
		//定义数组
		int[] arr = new int[]{ -10,2,3,246,-100,0,5} ;
		//定义数组中的最大值，初始化为arr[0]
		int max=arr[0];
		//定义数组中的最小值，初始化为arr[0]
		int min=arr[0];
		//定义求和参数
		int iSum=0;
		for(int i=0;i<arr.length;i++) {
			if(arr[i]>max) {
				max=arr[i];
			}
			if(arr[i]<min) {
				min=arr[i];
			}
			iSum+=arr[i];
			}
		//遍历输出数组
		for(int i=0 ;i<arr.length;i++) {
			System.out.print(arr[i]+" ");
		}
		//回车
		System.out.println();
		//输出数组中最大值最小值及平均值
		System.out.println("最大值为"+max+"，最小值为"+min+",平均值为"+(double)iSum/arr.length);
		
	}
	
	
	
	
	
	
	
	
	
	
	/**
	 * 8.将一个数组中的重复元素保留一个其他的清零。
	 * （知识点：数组遍历、数组元素访问）
	 * @param array
	 */
	private static void onlyOne(int[] array) {
		//定义数组长度
		int leng=array.length;
		//
		for(int i=0;i<leng;i++) {
			for(int j=1;j<leng;j++) {
				if(i!=j&&array[i]==array[j]) {
					array[j]=0;
				}
			}
		}
		
		for(int i=0;i<leng;i++) {
			System.out.print(array[i]+" ");
		}
		System.out.println();
		
	}
	
	
	
	
	
	
	
	/*
	 * 7.将一个数组中的元素逆序存放（知识点：数组遍历、数组元素访问） [选作题]
	 */
	private static void reverse(int[] array) {
		//定义数组长度
		int leng=array.length;
		//for循环交换
		for(int i=0;i<leng/2;i++) {
			int temp =array[i];
			array[i]= array[leng-1-i];
			array[leng-1-i]=temp;
		}
		//输出反转后的数组
		System.out.println("逆序存放的数组为：");
		for(int i=0;i<leng;i++) {
			System.out.print(array[i]+" ");
		}
		//所有输出结束后换行
		System.out.println();
		
	}
	
	
	
	
	
	
	
	
	/*
	 * 6.在一个有8个整数（18，25，7，36，13，2，89，63）
	 * 的数组中找出其中最大的数及其下标。（
	 * 知识点：数组遍历、数组元素访问） [必做题]
	 */
	private static void Max(int[] array) {
		//定义max
		int max = array[0];
		//定义下标
		int maxIndex = 0;
		//循环
		for(int i=0;i<array.length;i++) {
			if(array[i]>max) {
				max=array[i];
				maxIndex=i;
			}
		}
		
		System.out.println("最大值为"+max+"  下标为"+maxIndex);
		
	}
	
	
	
	
	
	

	/*-indent
	 * 
	 * 5.输出一个double型二维数组（长度分别为5、4，值自己设定）的值。 
	 * （知识点：数组定义和创建、多维数组初始化、数组遍历） [必做题]
	 */
	private static void doubleArr() {
		
		//定义浮点型二维数组
		double[][] dArr=new double[5][4];
		//遍历数组并赋值
		for(int i=0;i<dArr.length;i++) {
			for(int j=0;j<dArr[i].length;j++) {
				dArr[i][j]=Math.random();
			}
		}
		
		//遍历数组输出
		for(int i=0;i<5;i++) {
			for(int j=0;j<4;j++) {
				System.out.printf("%4.2f    ",dArr[i][j]*100);
			}
			System.out.println();
		}
	}
	
	
	
	
	
	
	
	

	/*-
	 * 4.矩阵乘法
	 * 有2个多维数组分别是 2 3 4   和  1 5 2 8 
	 *   		         4 6 8     5 9 10 -3 
	 *		                       2 7 -5 -18
	 * 按照如下方式进行运算。     * 生成一个2行4列的数组。
	 * 此数组的第1行1列是2*1+3*5+4*2
	 * 第1行2列是2*5+3*9+4*7  
	 * 第2行1列是4*1+6*5+8*2 依次类推。
	 * （知识点：多维数组定义和创建、数组遍历、数组元素访问） [选作题]
	 * indent(1)
	 */
	private static void matrixMulti() {
		// 定义数组a
		int[][] a = { { 2, 3, 4 }, { 4, 6, 8 } };
		// 定义数组b
		int[][] b = { { 1, 5, 2, 8 }, { 5, 9, 10, -3 }, { 2, 7, -5, -18 } };
		// 定义数组c=a*b的矩阵乘法
		int[][] c = new int[2][4];

		// for循环给c中每个元素赋值
		// c的行
		for (int i = 0; i < 2; i++) {
			// c的列
			for (int j = 0; j < 4; j++) {
				// 再嵌套循环赋值
				// 矩阵乘法规律
				for (int m = 0; m < 3; m++) {
					c[i][j] += a[i][m] * b[m][j];
				}
				// 输出计算完的元素
				System.out.println("c[" + i + "][" + j + "] =  " + c[i][j]);

			}
		}
		// 双重循环遍历数组C
		for (int i = 0; i < c.length; i++) {
			for (int j = 0; j < c[0].length; j++) {
				System.out.print(c[i][j] + " ");
			}
			// 遍历一行后输出
			System.out.println();
		}

	}

	/*-indent
	 * 3.给定一个有9个整数（1,6,2,3,9,4,5,7,8）的数组， 先排序，
	 * 然后输出排序后的数组的值。 （知识点：Arrays.sort排序、冒泡排序）
	 * [必做题]
	 */
	private static void bubbleSort(int[] array) {

		for (int i = 0; i < array.length; i++) {
			for (int j = 0; j < array.length - i - 1; j++) {
				if (array[j] > array[j + 1]) {
					int temp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = temp;
				}
			}
		}
		// 遍历输出数组
		for (int k = 0; k < array.length; k++) {
			System.out.print(array[k] + ",");
		}

	}

	/**
	 * 2.将一个字符数组的值（neusofteducation） 拷贝到另一个字符数组中。（知识点：数组复制） [必做题]
	 */
	private static void copyArr() {
		// 字符串变量
		String str = "neusofteducation";
		// 定义原始字符数组
		char[] array1 = str.toCharArray();
		// 定义复制后的数组
		char[] array2 = new char[20];
//		// 复制数组内容
//		// 这块容易出现越界问题
//		for (int i = 0; i < array1.length; i++) {
//			array2[i] = array1[i];
//			// System.out.println(array2[i]);
//		}
		//调用方法赋值
		System.arraycopy(array1, 0, array2, 0, array1.length);
		// 输出复制后的数组
		System.out.println("输出复制后的数组");
		for (int i = 0; i < array2.length; i++) {
			System.out.print(array2[i]);
		}
		System.out.println();
	}

	/**
	 * 1.编写一个简单程序，要求数组长度为5， 分别赋值10，20，30，40，50，在控制台输出该数组的值。
	 * （知识点：数组定义和创建、一维数组初始化）[必做题]
	 *
	 */

	private static void testArray01() {
		// 定义一个数组
		int[] array01 = new int[] { 10, 20, 30, 40, 50 };

		// 遍历输出
		for (int i = 0; i < array01.length; i++) {
			System.out.print(array01[i] + " ");
		}
		// 换行
		System.out.println();
	}

}
